SonarSource Rules
  • Products

    In-IDE

    Code Quality and Security in your IDE with SonarQube Ide

    IDE extension that lets you fix coding issues before they exist!

    Discover SonarQube for IDE

    SaaS

    Code Quality and Security in the cloud with SonarQube Cloud

    Setup is effortless and analysis is automatic for most languages

    Discover SonarQube Cloud

    Self-Hosted

    Code Quality and Security Self-Hosted with SonarQube Server

    Fast, accurate analysis; enterprise scalability

    Discover SonarQube Server
  • SecretsSecrets
  • ABAPABAP
  • AnsibleAnsible
  • ApexApex
  • AzureResourceManagerAzureResourceManager
  • CC
  • C#C#
  • C++C++
  • CloudFormationCloudFormation
  • COBOLCOBOL
  • CSSCSS
  • DartDart
  • DockerDocker
  • FlexFlex
  • GitHub ActionsGitHub Actions
  • GoGo
  • HTMLHTML
  • JavaJava
  • JavaScriptJavaScript
  • JSONJSON
  • JCLJCL
  • KotlinKotlin
  • KubernetesKubernetes
  • Objective CObjective C
  • PHPPHP
  • PL/IPL/I
  • PL/SQLPL/SQL
  • PythonPython
  • RPGRPG
  • RubyRuby
  • RustRust
  • ScalaScala
  • ShellShell
  • SwiftSwift
  • TerraformTerraform
  • TextText
  • TypeScriptTypeScript
  • T-SQLT-SQL
  • VB.NETVB.NET
  • VB6VB6
  • XMLXML
  • YAMLYAML
Apex

Apex static code analysis

Unique rules to find Bugs, Vulnerabilities, Security Hotspots, and Code Smells in your APEX code

  • All rules 97
  • Vulnerability2
  • Bug26
  • Security Hotspot3
  • Code Smell66
 
Tags
    Impact
      Clean code attribute
        1. Arguments to "assertEquals" and "assertNotEquals" should be in the correct order

           Code Smell
        2. String conversions should use explicit methods instead of empty string concatenation

           Code Smell
        3. Abstract classes should contain at least one abstract or virtual method

           Code Smell
        4. SOQL queries should not contain hardcoded date literals

           Code Smell
        5. SOQL queries should not be executed inside loops

           Code Smell
        6. Custom exception classes should follow proper naming conventions

           Code Smell
        7. Loops should use braces

           Code Smell
        8. SOSL queries in test methods should use "Test.setFixedSearchResults"

           Code Smell
        9. Constants should use SNAKE_CASE with all uppercase letters

           Code Smell
        10. Builder pattern methods should return the builder instance to enable method chaining

           Code Smell
        11. Test classes and methods should not use "seeAllData=true"

           Code Smell
        12. HTTP requests should have explicit timeout configuration

           Code Smell
        13. Singleton classes should have private constructors

           Code Smell
        14. "getRoleAndSubordinates()" should be replaced with "getRoleAndSubordinatesInternal()"

           Code Smell
        15. "String.isEmpty()" should be replaced with "String.isBlank()" for comprehensive validation

           Code Smell
        16. SOQL queries should use SystemModStamp instead of LastModifiedDate for better performance

           Code Smell
        17. Catch blocks should not be empty

           Code Smell
        18. Apex classes and methods should have explicit access modifiers

           Code Smell
        19. Test classes should be annotated with "@isTest"

           Code Smell
        20. Private members made public for testing should use "@TestVisible" annotation

           Code Smell
        21. Batch Apex scope parameters should not exceed 2000 records

           Code Smell
        22. Custom event names should not be prefixed with "on"

           Code Smell
        23. Catch specific exception types instead of generic "Exception"

           Code Smell
        24. Test methods should include meaningful assertions

           Code Smell
        25. InvocableMethod annotations should include descriptive label and description

           Code Smell
        26. Test methods should not be annotated with "@isTest(SeeAllData=true)"

           Code Smell
        27. Tested code should be enclosed between "Test.StartTest()" and "Test.StopTest()"

           Code Smell
        28. Messages should not be hardcoded

           Code Smell
        29. System.runAs should be used to test user permissions

           Code Smell
        30. SOQL COUNT should be used instead of the method size()

           Code Smell
        31. Business logic should not be implemented inside Triggers

           Code Smell
        32. Multi-line comments should not be empty

           Code Smell
        33. Methods should not have identical implementations

           Code Smell
        34. Cognitive Complexity of functions should not be too high

           Code Smell
        35. Track parsing failures

           Code Smell
        36. Boolean checks should not be inverted

           Code Smell
        37. Two branches in a conditional structure should not have exactly the same implementation

           Code Smell
        38. "switch" statements should not be nested

           Code Smell
        39. Unused local variables should be removed

           Code Smell
        40. "switch" statements should not have too many "case" clauses

           Code Smell
        41. Track lack of copyright and license headers

           Code Smell
        42. Functions should not have too many lines of code

           Code Smell
        43. Control flow statements "if", "for", "while", "switch" and "try" should not be nested too deeply

           Code Smell
        44. "switch" statements should have "when else" clauses

           Code Smell
        45. "if ... else if" constructs should end with "else" clauses

           Code Smell
        46. Sections of code should not be commented out

           Code Smell
        47. Statements should be on separate lines

           Code Smell
        48. String literals should not be duplicated

           Code Smell
        49. Methods should not be empty

           Code Smell
        50. Unused function parameters should be removed

           Code Smell
        51. Local variable and method parameter names should comply with a naming convention

           Code Smell
        52. "when" clauses should not have too many lines of code

           Code Smell
        53. Unused "private" methods should be removed

           Code Smell
        54. Track uses of "TODO" tags

           Code Smell
        55. Track uses of "FIXME" tags

           Code Smell
        56. Boolean literals should not be redundant

           Code Smell
        57. Redundant pairs of parentheses should be removed

           Code Smell
        58. Nested blocks of code should not be left empty

           Code Smell
        59. Functions should not have too many parameters

           Code Smell
        60. Expressions should not be too complex

           Code Smell
        61. Mergeable "if" statements should be combined

           Code Smell
        62. Tabulation characters should not be used

           Code Smell
        63. Files should not have too many lines of code

           Code Smell
        64. Lines should not be too long

           Code Smell
        65. Class names should comply with a naming convention

           Code Smell
        66. Function names should comply with a naming convention

           Code Smell

        String conversions should use explicit methods instead of empty string concatenation

        intentionality - clear
        maintainability
        Code Smell
        • performance
        • readability

        This rule raises an issue when values are converted to strings by concatenating them with empty strings ('').

        Why is this an issue?

        How can I fix it?

        More Info

        Converting values to strings by concatenating them with empty strings is an inefficient and unclear practice.

        When you write '' + someValue, the Apex runtime must:

        • Create a temporary string object for the empty string
        • Convert someValue to its string representation
        • Concatenate these two strings
        • Return the result

        This process involves unnecessary object creation and string manipulation overhead.

        Using explicit toString() methods is more efficient because:

        • It directly converts the value to a string without intermediate steps
        • The intent is clearer to other developers reading your code
        • It follows Apex best practices for type conversion

        The performance difference becomes more noticeable when this pattern is used frequently, such as in loops or bulk operations common in Salesforce development.

        What is the potential impact?

        This issue impacts code performance and maintainability:

        • Performance degradation: Unnecessary object creation and string operations can slow down your code, especially in bulk operations
        • Reduced readability: The intent to convert a value to string is less clear when using concatenation
        • Maintenance overhead: Code reviewers and future developers may not immediately understand the purpose of empty string concatenation
          Available In:
        • SonarQube CloudDetect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories

        © 2008-2025 SonarSource SA. All rights reserved.

        Privacy Policy | Cookie Policy | Terms of Use